Termination w.r.t. Q proof of /tmp/tmpzYJAkT/ExSec4_2_DLMMU04

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(snd(X)) → A__SND(mark(X))
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
MARK(s(X)) → MARK(X)
A__TAKE(N, XS) → MARK(XS)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → MARK(XS)
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(X)) → MARK(X)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SPLITAT(s(N), cons(X, XS)) → A__SPLITAT(mark(N), mark(XS))
MARK(fst(X)) → A__FST(mark(X))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__NATSFROM(N) → MARK(N)
A__TAKE(N, XS) → MARK(N)
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(snd(X)) → A__SND(mark(X))
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
MARK(s(X)) → MARK(X)
A__TAKE(N, XS) → MARK(XS)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → MARK(XS)
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(X)) → MARK(X)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SPLITAT(s(N), cons(X, XS)) → A__SPLITAT(mark(N), mark(XS))
MARK(fst(X)) → A__FST(mark(X))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__NATSFROM(N) → MARK(N)
A__TAKE(N, XS) → MARK(N)
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__SPLITAT(s(N), cons(X, XS)) → A__SPLITAT(mark(N), mark(XS)) at position [0] we obtained the following new rules:

A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
A__SPLITAT(s(nil), cons(y1, y2)) → A__SPLITAT(nil, mark(y2))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__SPLITAT(s(pair(x0, x1)), cons(y1, y2)) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__SPLITAT(s(cons(x0, x1)), cons(y1, y2)) → A__SPLITAT(cons(mark(x0), x1), mark(y2))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
A__SPLITAT(s(nil), cons(y1, y2)) → A__SPLITAT(nil, mark(y2))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(snd(X)) → A__SND(mark(X))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
A__SPLITAT(s(cons(x0, x1)), cons(y1, y2)) → A__SPLITAT(cons(mark(x0), x1), mark(y2))
MARK(take(X1, X2)) → MARK(X1)
MARK(head(X)) → A__HEAD(mark(X))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__SPLITAT(s(pair(x0, x1)), cons(y1, y2)) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y2))
A__TAIL(cons(N, XS)) → MARK(XS)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__TAKE(N, XS) → MARK(XS)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(X)) → MARK(X)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(fst(X)) → A__FST(mark(X))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__TAKE(N, XS) → MARK(N)
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(snd(X)) → A__SND(mark(X))
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__TAKE(N, XS) → MARK(XS)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
A__SEL(N, XS) → MARK(XS)
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(X)) → MARK(X)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(fst(X)) → A__FST(mark(X))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__TAKE(N, XS) → MARK(N)
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(fst(X)) → A__FST(mark(X)) at position [0] we obtained the following new rules:

MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(cons(x0, x1))) → A__FST(cons(mark(x0), x1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(fst(nil)) → A__FST(nil)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(fst(s(x0))) → A__FST(s(mark(x0)))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(0)) → A__FST(0)
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(snd(X)) → A__SND(mark(X))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(take(X1, X2)) → MARK(X1)
MARK(head(X)) → A__HEAD(mark(X))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(0)) → A__FST(0)
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(fst(cons(x0, x1))) → A__FST(cons(mark(x0), x1))
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(X)) → MARK(X)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(fst(nil)) → A__FST(nil)
MARK(fst(s(x0))) → A__FST(s(mark(x0)))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__TAKE(N, XS) → MARK(N)
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(snd(X)) → A__SND(mark(X))
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__SEL(N, XS) → MARK(XS)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(X)) → MARK(X)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(snd(X)) → A__SND(mark(X)) at position [0] we obtained the following new rules:

MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(snd(0)) → A__SND(0)
MARK(snd(s(x0))) → A__SND(s(mark(x0)))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(snd(nil)) → A__SND(nil)
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(snd(cons(x0, x1))) → A__SND(cons(mark(x0), x1))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(take(X1, X2)) → MARK(X1)
MARK(head(X)) → A__HEAD(mark(X))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(snd(nil)) → A__SND(nil)
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → MARK(XS)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(snd(s(x0))) → A__SND(s(mark(x0)))
MARK(pair(X1, X2)) → MARK(X2)
MARK(snd(cons(x0, x1))) → A__SND(cons(mark(x0), x1))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(snd(0)) → A__SND(0)
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__SEL(N, XS) → MARK(XS)
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(splitAt(X1, X2)) → A__SPLITAT(mark(X1), mark(X2)) at position [0] we obtained the following new rules:

MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(pair(x0, x1), y1)) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(splitAt(nil, y1)) → A__SPLITAT(nil, mark(y1))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(cons(x0, x1), y1)) → A__SPLITAT(cons(mark(x0), x1), mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(take(X1, X2)) → MARK(X2)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
MARK(splitAt(nil, y1)) → A__SPLITAT(nil, mark(y1))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(tail(X)) → A__TAIL(mark(X))
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(pair(x0, x1), y1)) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(cons(x0, x1), y1)) → A__SPLITAT(cons(mark(x0), x1), mark(y1))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4)
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__HEAD(cons(N, XS)) → MARK(N)
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(X)) → A__TAIL(mark(X))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__SEL(N, XS) → MARK(XS)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))
MARK(sel(X1, X2)) → MARK(X2)

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(u(X1, X2, X3, X4)) → A__U(mark(X1), X2, X3, X4) at position [0] we obtained the following new rules:

MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(cons(x0, x1), y1, y2, y3)) → A__U(cons(mark(x0), x1), y1, y2, y3)
MARK(u(s(x0), y1, y2, y3)) → A__U(s(mark(x0)), y1, y2, y3)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(0, y1, y2, y3)) → A__U(0, y1, y2, y3)
MARK(u(nil, y1, y2, y3)) → A__U(nil, y1, y2, y3)
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(take(X1, X2)) → MARK(X2)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
MARK(u(s(x0), y1, y2, y3)) → A__U(s(mark(x0)), y1, y2, y3)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(u(nil, y1, y2, y3)) → A__U(nil, y1, y2, y3)
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(head(X)) → A__HEAD(mark(X))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(tail(X)) → A__TAIL(mark(X))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(u(cons(x0, x1), y1, y2, y3)) → A__U(cons(mark(x0), x1), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(u(0, y1, y2, y3)) → A__U(0, y1, y2, y3)
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(take(X1, X2)) → MARK(X2)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → MARK(XS)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(take(X1, X2)) → MARK(X1)
MARK(head(X)) → A__HEAD(mark(X))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(tail(X)) → A__TAIL(mark(X))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(head(X)) → A__HEAD(mark(X)) at position [0] we obtained the following new rules:

MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(head(nil)) → A__HEAD(nil)
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
MARK(head(s(x0))) → A__HEAD(s(mark(x0)))
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(head(pair(x0, x1))) → A__HEAD(pair(mark(x0), mark(x1)))
MARK(head(0)) → A__HEAD(0)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → MARK(X2)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__TAKE(N, XS) → MARK(N)
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
MARK(head(0)) → A__HEAD(0)
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(X)) → A__TAIL(mark(X))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
MARK(head(s(x0))) → A__HEAD(s(mark(x0)))
MARK(head(nil)) → A__HEAD(nil)
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
MARK(head(pair(x0, x1))) → A__HEAD(pair(mark(x0), mark(x1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(take(X1, X2)) → MARK(X2)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(tail(X)) → A__TAIL(mark(X))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(tail(X)) → A__TAIL(mark(X)) at position [0] we obtained the following new rules:

MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(tail(nil)) → A__TAIL(nil)
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(tail(s(x0))) → A__TAIL(s(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
MARK(tail(pair(x0, x1))) → A__TAIL(pair(mark(x0), mark(x1)))
MARK(tail(0)) → A__TAIL(0)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(tail(s(x0))) → A__TAIL(s(mark(x0)))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(tail(pair(x0, x1))) → A__TAIL(pair(mark(x0), mark(x1)))
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → MARK(X2)
MARK(tail(nil)) → A__TAIL(nil)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(tail(0)) → A__TAIL(0)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__SEL(N, XS) → A__HEAD(a__afterNth(mark(N), mark(XS))) at position [0] we obtained the following new rules:

A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, y1) → A__HEAD(afterNth(mark(y0), mark(y1)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(N, XS) → MARK(N)
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → MARK(X2)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
A__SEL(y0, y1) → A__HEAD(afterNth(mark(y0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(N, XS) → MARK(N)
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(X)) → MARK(X)
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(cons(X1, X2)) → MARK(X1)
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__TAIL(cons(N, XS)) → MARK(XS)
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__AFTERNTH(N, XS) → A__SND(a__splitAt(mark(N), mark(XS))) at position [0] we obtained the following new rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__AFTERNTH(y0, y1) → A__SND(splitAt(mark(y0), mark(y1)))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(N, XS) → MARK(N)
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → MARK(X2)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
MARK(cons(X1, X2)) → MARK(X1)
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(splitAt(X1, X2)) → MARK(X1)
MARK(pair(X1, X2)) → MARK(X1)
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, y1) → A__SND(splitAt(mark(y0), mark(y1)))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(N, XS) → MARK(N)
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
MARK(fst(X)) → MARK(X)
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__HEAD(cons(N, XS)) → MARK(N)
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(N, XS) → MARK(XS)
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
MARK(sel(X1, X2)) → MARK(X2)
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
MARK(splitAt(X1, X2)) → MARK(X1)
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SPLITAT(0, XS) → MARK(XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__TAKE(N, XS) → MARK(XS)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(snd(X)) → MARK(X)
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__AFTERNTH(N, XS) → A__SPLITAT(mark(N), mark(XS)) at position [0] we obtained the following new rules:

A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(cons(x0, x1), y1) → A__SPLITAT(cons(mark(x0), x1), mark(y1))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(pair(x0, x1), y1) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__AFTERNTH(nil, y1) → A__SPLITAT(nil, mark(y1))
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__AFTERNTH(nil, y1) → A__SPLITAT(nil, mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(cons(x0, x1), y1) → A__SPLITAT(cons(mark(x0), x1), mark(y1))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → MARK(XS)
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(pair(x0, x1), y1) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS)))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__SEL(N, XS) → MARK(N)
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__TAKE(N, XS) → A__FST(a__splitAt(mark(N), mark(XS))) at position [0] we obtained the following new rules:

A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, y1) → A__FST(splitAt(mark(y0), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__TAKE(y0, y1) → A__FST(splitAt(mark(y0), mark(y1)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → MARK(XS)
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS))
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__TAKE(N, XS) → A__SPLITAT(mark(N), mark(XS)) at position [0] we obtained the following new rules:

A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(cons(x0, x1), y1) → A__SPLITAT(cons(mark(x0), x1), mark(y1))
A__TAKE(nil, y1) → A__SPLITAT(nil, mark(y1))
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(pair(x0, x1), y1) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y1))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__TAKE(nil, y1) → A__SPLITAT(nil, mark(y1))
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(cons(x0, x1), y1) → A__SPLITAT(cons(mark(x0), x1), mark(y1))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
A__TAKE(pair(x0, x1), y1) → A__SPLITAT(pair(mark(x0), mark(x1)), mark(y1))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(u(natsFrom(x0), y1, y2, y3)) → A__U(a__natsFrom(mark(x0)), y1, y2, y3)
MARK(fst(natsFrom(x0))) → A__FST(a__natsFrom(mark(x0)))

The remaining pairs can at least be oriented weakly.

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(A__AFTERNTH(x₁, x₂)) = 1
POL(A__FST(x₁)) = x₁
POL(A__HEAD(x₁)) = 1
POL(A__NATSFROM(x₁)) = 1
POL(A__SEL(x₁, x₂)) = 1
POL(A__SND(x₁)) = 1
POL(A__SPLITAT(x₁, x₂)) = 1
POL(A__TAIL(x₁)) = 1
POL(A__TAKE(x₁, x₂)) = 1
POL(A__U(x₁, x₂, x₃, x₄)) = x₁
POL(MARK(x₁)) = 1
POL(a__afterNth(x₁, x₂)) = 1
POL(a__fst(x₁)) = 1
POL(a__head(x₁)) = 1
POL(a__natsFrom(x₁)) = 0
POL(a__sel(x₁, x₂)) = 1
POL(a__snd(x₁)) = x₁
POL(a__splitAt(x₁, x₂)) = 1
POL(a__tail(x₁)) = 1
POL(a__take(x₁, x₂)) = 1
POL(a__u(x₁, x₂, x₃, x₄)) = x₁
POL(afterNth(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(fst(x₁)) = 0
POL(head(x₁)) = 0
POL(mark(x₁)) = 1
POL(natsFrom(x₁)) = 0
POL(nil) = 0
POL(pair(x₁, x₂)) = 1
POL(s(x₁)) = 0
POL(sel(x₁, x₂)) = 0
POL(snd(x₁)) = x₁
POL(splitAt(x₁, x₂)) = 1
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = 1
POL(u(x₁, x₂, x₃, x₄)) = x₁

The following usable rules [17] were oriented:

a__splitAt(0, XS) → pair(nil, mark(XS))
a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(nil) → nil
mark(0) → 0
a__fst(X) → fst(X)
a__natsFrom(X) → natsFrom(X)
mark(fst(X)) → a__fst(mark(X))
a__fst(pair(XS, YS)) → mark(XS)
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(tail(X)) → a__tail(mark(X))
mark(snd(X)) → a__snd(mark(X))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
a__head(cons(N, XS)) → mark(N)
a__snd(pair(XS, YS)) → mark(YS)
a__tail(cons(N, XS)) → mark(XS)
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(head(X)) → a__head(mark(X))
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(tail(u(x0, x1, x2, x3))) → A__TAIL(a__u(mark(x0), x1, x2, x3))
MARK(tail(splitAt(x0, x1))) → A__TAIL(a__splitAt(mark(x0), mark(x1)))

The remaining pairs can at least be oriented weakly.

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(A__AFTERNTH(x₁, x₂)) = 1
POL(A__FST(x₁)) = 1
POL(A__HEAD(x₁)) = 1
POL(A__NATSFROM(x₁)) = 1
POL(A__SEL(x₁, x₂)) = 1
POL(A__SND(x₁)) = 1
POL(A__SPLITAT(x₁, x₂)) = 1
POL(A__TAIL(x₁)) = x₁
POL(A__TAKE(x₁, x₂)) = 1
POL(A__U(x₁, x₂, x₃, x₄)) = 1
POL(MARK(x₁)) = 1
POL(a__afterNth(x₁, x₂)) = 1
POL(a__fst(x₁)) = 1
POL(a__head(x₁)) = 1
POL(a__natsFrom(x₁)) = 1
POL(a__sel(x₁, x₂)) = 1
POL(a__snd(x₁)) = 1
POL(a__splitAt(x₁, x₂)) = 0
POL(a__tail(x₁)) = 1
POL(a__take(x₁, x₂)) = 1
POL(a__u(x₁, x₂, x₃, x₄)) = 0
POL(afterNth(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 1
POL(fst(x₁)) = 0
POL(head(x₁)) = 0
POL(mark(x₁)) = 1
POL(natsFrom(x₁)) = 1
POL(nil) = 0
POL(pair(x₁, x₂)) = 0
POL(s(x₁)) = 0
POL(sel(x₁, x₂)) = 0
POL(snd(x₁)) = 0
POL(splitAt(x₁, x₂)) = 0
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(u(x₁, x₂, x₃, x₄)) = 0

The following usable rules [17] were oriented:

a__splitAt(0, XS) → pair(nil, mark(XS))
a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(nil) → nil
mark(0) → 0
a__fst(X) → fst(X)
a__natsFrom(X) → natsFrom(X)
mark(fst(X)) → a__fst(mark(X))
a__fst(pair(XS, YS)) → mark(XS)
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(tail(X)) → a__tail(mark(X))
mark(snd(X)) → a__snd(mark(X))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
a__head(cons(N, XS)) → mark(N)
a__snd(pair(XS, YS)) → mark(YS)
a__tail(cons(N, XS)) → mark(XS)
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(head(X)) → a__head(mark(X))
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A__AFTERNTH(cons(x0, x1), y1) → A__SND(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(nil, y1) → A__SND(a__splitAt(nil, mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__FST(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))
A__TAKE(nil, y1) → A__FST(a__splitAt(nil, mark(y1)))
MARK(snd(natsFrom(x0))) → A__SND(a__natsFrom(mark(x0)))
A__TAKE(cons(x0, x1), y1) → A__FST(a__splitAt(cons(mark(x0), x1), mark(y1)))
A__AFTERNTH(natsFrom(x0), y1) → A__SND(a__splitAt(a__natsFrom(mark(x0)), mark(y1)))

The remaining pairs can at least be oriented weakly.

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(A__AFTERNTH(x₁, x₂)) = 1
POL(A__FST(x₁)) = x₁
POL(A__HEAD(x₁)) = 1
POL(A__NATSFROM(x₁)) = 1
POL(A__SEL(x₁, x₂)) = 1
POL(A__SND(x₁)) = x₁
POL(A__SPLITAT(x₁, x₂)) = 1
POL(A__TAIL(x₁)) = 1
POL(A__TAKE(x₁, x₂)) = 1
POL(A__U(x₁, x₂, x₃, x₄)) = 1
POL(MARK(x₁)) = 1
POL(a__afterNth(x₁, x₂)) = 1
POL(a__fst(x₁)) = 1
POL(a__head(x₁)) = 1
POL(a__natsFrom(x₁)) = 0
POL(a__sel(x₁, x₂)) = 1
POL(a__snd(x₁)) = x₁
POL(a__splitAt(x₁, x₂)) = x₁
POL(a__tail(x₁)) = 1
POL(a__take(x₁, x₂)) = 1
POL(a__u(x₁, x₂, x₃, x₄)) = x₁
POL(afterNth(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(fst(x₁)) = 0
POL(head(x₁)) = 1
POL(mark(x₁)) = 1
POL(natsFrom(x₁)) = 0
POL(nil) = 0
POL(pair(x₁, x₂)) = 1
POL(s(x₁)) = 1
POL(sel(x₁, x₂)) = 1
POL(snd(x₁)) = x₁
POL(splitAt(x₁, x₂)) = x₁
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(u(x₁, x₂, x₃, x₄)) = x₁

The following usable rules [17] were oriented:

a__splitAt(0, XS) → pair(nil, mark(XS))
a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(nil) → nil
mark(0) → 0
a__fst(X) → fst(X)
a__natsFrom(X) → natsFrom(X)
mark(fst(X)) → a__fst(mark(X))
a__fst(pair(XS, YS)) → mark(XS)
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(tail(X)) → a__tail(mark(X))
mark(snd(X)) → a__snd(mark(X))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
a__head(cons(N, XS)) → mark(N)
a__snd(pair(XS, YS)) → mark(YS)
a__tail(cons(N, XS)) → mark(XS)
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(head(X)) → a__head(mark(X))
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(head(splitAt(x0, x1))) → A__HEAD(a__splitAt(mark(x0), mark(x1)))
MARK(head(u(x0, x1, x2, x3))) → A__HEAD(a__u(mark(x0), x1, x2, x3))

The remaining pairs can at least be oriented weakly.

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(A__AFTERNTH(x₁, x₂)) = 1
POL(A__FST(x₁)) = 1
POL(A__HEAD(x₁)) = x₁
POL(A__NATSFROM(x₁)) = 1
POL(A__SEL(x₁, x₂)) = 1
POL(A__SND(x₁)) = 1
POL(A__SPLITAT(x₁, x₂)) = 1
POL(A__TAIL(x₁)) = 1
POL(A__TAKE(x₁, x₂)) = 1
POL(A__U(x₁, x₂, x₃, x₄)) = 1
POL(MARK(x₁)) = 1
POL(a__afterNth(x₁, x₂)) = 1
POL(a__fst(x₁)) = 1
POL(a__head(x₁)) = 1
POL(a__natsFrom(x₁)) = 1
POL(a__sel(x₁, x₂)) = 1
POL(a__snd(x₁)) = 1
POL(a__splitAt(x₁, x₂)) = 0
POL(a__tail(x₁)) = x₁
POL(a__take(x₁, x₂)) = 1
POL(a__u(x₁, x₂, x₃, x₄)) = 0
POL(afterNth(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 1
POL(fst(x₁)) = 0
POL(head(x₁)) = 0
POL(mark(x₁)) = 1
POL(natsFrom(x₁)) = 0
POL(nil) = 0
POL(pair(x₁, x₂)) = 0
POL(s(x₁)) = 0
POL(sel(x₁, x₂)) = 1
POL(snd(x₁)) = 0
POL(splitAt(x₁, x₂)) = 0
POL(tail(x₁)) = x₁
POL(take(x₁, x₂)) = 0
POL(u(x₁, x₂, x₃, x₄)) = 0

The following usable rules [17] were oriented:

a__splitAt(0, XS) → pair(nil, mark(XS))
a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(nil) → nil
mark(0) → 0
a__fst(X) → fst(X)
a__natsFrom(X) → natsFrom(X)
mark(fst(X)) → a__fst(mark(X))
a__fst(pair(XS, YS)) → mark(XS)
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(tail(X)) → a__tail(mark(X))
mark(snd(X)) → a__snd(mark(X))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
a__head(cons(N, XS)) → mark(N)
a__snd(pair(XS, YS)) → mark(YS)
a__tail(cons(N, XS)) → mark(XS)
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(head(X)) → a__head(mark(X))
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A__TAKE(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(splitAt(natsFrom(x0), y1)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
MARK(splitAt(splitAt(x0, x1), y1)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(natsFrom(x0)), cons(y1, y2)) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y2))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(natsFrom(x0), y1) → A__SPLITAT(a__natsFrom(mark(x0)), mark(y1))
A__TAKE(splitAt(x0, x1), y1) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(u(x0, x1, x2, x3)), cons(y1, y2)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y2))
A__TAKE(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
MARK(splitAt(u(x0, x1, x2, x3), y1)) → A__SPLITAT(a__u(mark(x0), x1, x2, x3), mark(y1))
A__SPLITAT(s(splitAt(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__splitAt(mark(x0), mark(x1)), mark(y2))

The remaining pairs can at least be oriented weakly.

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(A__AFTERNTH(x₁, x₂)) = 1
POL(A__FST(x₁)) = 1
POL(A__HEAD(x₁)) = 1
POL(A__NATSFROM(x₁)) = 1
POL(A__SEL(x₁, x₂)) = 1
POL(A__SND(x₁)) = 1
POL(A__SPLITAT(x₁, x₂)) = x₁
POL(A__TAIL(x₁)) = 1
POL(A__TAKE(x₁, x₂)) = 1
POL(A__U(x₁, x₂, x₃, x₄)) = 1
POL(MARK(x₁)) = 1
POL(a__afterNth(x₁, x₂)) = 1
POL(a__fst(x₁)) = 1
POL(a__head(x₁)) = 1
POL(a__natsFrom(x₁)) = 0
POL(a__sel(x₁, x₂)) = 1
POL(a__snd(x₁)) = 1
POL(a__splitAt(x₁, x₂)) = 0
POL(a__tail(x₁)) = 1
POL(a__take(x₁, x₂)) = 1
POL(a__u(x₁, x₂, x₃, x₄)) = 0
POL(afterNth(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(fst(x₁)) = 0
POL(head(x₁)) = 0
POL(mark(x₁)) = 1
POL(natsFrom(x₁)) = 0
POL(nil) = 0
POL(pair(x₁, x₂)) = 0
POL(s(x₁)) = 1
POL(sel(x₁, x₂)) = 0
POL(snd(x₁)) = 0
POL(splitAt(x₁, x₂)) = 0
POL(tail(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(u(x₁, x₂, x₃, x₄)) = 0

The following usable rules [17] were oriented:

a__splitAt(0, XS) → pair(nil, mark(XS))
a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(s(X)) → s(mark(X))
mark(nil) → nil
mark(0) → 0
a__fst(X) → fst(X)
a__natsFrom(X) → natsFrom(X)
mark(fst(X)) → a__fst(mark(X))
a__fst(pair(XS, YS)) → mark(XS)
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(tail(X)) → a__tail(mark(X))
mark(snd(X)) → a__snd(mark(X))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
a__head(cons(N, XS)) → mark(N)
a__snd(pair(XS, YS)) → mark(YS)
a__tail(cons(N, XS)) → mark(XS)
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(head(X)) → a__head(mark(X))
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ QDPOrderProof

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(splitAt(s(x0), y1)) → A__SPLITAT(s(mark(x0)), mark(y1)) at position [1] we obtained the following new rules:

MARK(splitAt(s(y0), nil)) → A__SPLITAT(s(mark(y0)), nil)
MARK(splitAt(s(y0), splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
MARK(splitAt(s(y0), natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
MARK(splitAt(s(y0), snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
MARK(splitAt(s(y0), pair(x0, x1))) → A__SPLITAT(s(mark(y0)), pair(mark(x0), mark(x1)))
MARK(splitAt(s(y0), u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
MARK(splitAt(s(y0), fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
MARK(splitAt(s(y0), s(x0))) → A__SPLITAT(s(mark(y0)), s(mark(x0)))
MARK(splitAt(s(y0), tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
MARK(splitAt(s(y0), sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
MARK(splitAt(s(y0), head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
MARK(splitAt(s(y0), afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(s(y0), cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(splitAt(s(y0), 0)) → A__SPLITAT(s(mark(y0)), 0)
MARK(splitAt(s(y0), take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ QDPOrderProof

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Narrowing

                                                                                                                            ↳ QDP

                                                                                                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(splitAt(s(y0), sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(s(y0), nil)) → A__SPLITAT(s(mark(y0)), nil)
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
MARK(splitAt(s(y0), pair(x0, x1))) → A__SPLITAT(s(mark(y0)), pair(mark(x0), mark(x1)))
MARK(splitAt(s(y0), u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(s(y0), splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(splitAt(s(y0), take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(splitAt(s(y0), fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
MARK(natsFrom(X)) → MARK(X)
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(splitAt(s(y0), 0)) → A__SPLITAT(s(mark(y0)), 0)
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(s(y0), afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(splitAt(s(y0), head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__TAKE(N, XS) → MARK(N)
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(y0), cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(splitAt(s(y0), natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(splitAt(s(y0), snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(s(y0), s(x0))) → A__SPLITAT(s(mark(y0)), s(mark(x0)))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
MARK(splitAt(s(y0), tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ QDPOrderProof

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Narrowing

                                                                                                                            ↳ QDP

                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(s(y0), sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
MARK(splitAt(s(y0), u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(s(y0), splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(splitAt(s(y0), take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
MARK(splitAt(s(y0), fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(s(y0), afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(splitAt(s(y0), head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(y0), cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(splitAt(s(y0), natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(splitAt(s(y0), snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
MARK(splitAt(s(y0), tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule A__SPLITAT(s(s(x0)), cons(y1, y2)) → A__SPLITAT(s(mark(x0)), mark(y2)) at position [1] we obtained the following new rules:

A__SPLITAT(s(s(y0)), cons(y1, pair(x0, x1))) → A__SPLITAT(s(mark(y0)), pair(mark(x0), mark(x1)))
A__SPLITAT(s(s(y0)), cons(y1, splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
A__SPLITAT(s(s(y0)), cons(y1, take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
A__SPLITAT(s(s(y0)), cons(y1, 0)) → A__SPLITAT(s(mark(y0)), 0)
A__SPLITAT(s(s(y0)), cons(y1, nil)) → A__SPLITAT(s(mark(y0)), nil)
A__SPLITAT(s(s(y0)), cons(y1, fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__SPLITAT(s(s(y0)), cons(y1, cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
A__SPLITAT(s(s(y0)), cons(y1, natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(s(y0)), cons(y1, head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, s(x0))) → A__SPLITAT(s(mark(y0)), s(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ QDPOrderProof

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Narrowing

                                                                                                                            ↳ QDP

                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(s(y0)), cons(y1, cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SPLITAT(s(s(y0)), cons(y1, u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
MARK(splitAt(s(y0), sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
A__SPLITAT(s(s(y0)), cons(y1, s(x0))) → A__SPLITAT(s(mark(y0)), s(mark(x0)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(s(y0)), cons(y1, sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
MARK(splitAt(s(y0), u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SPLITAT(s(s(y0)), cons(y1, take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
A__SPLITAT(s(s(y0)), cons(y1, nil)) → A__SPLITAT(s(mark(y0)), nil)
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(u(X1, X2, X3, X4)) → MARK(X1)
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__SPLITAT(s(s(y0)), cons(y1, snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(take(X1, X2)) → MARK(X1)
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(splitAt(s(y0), splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(N, XS) → MARK(XS)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(splitAt(s(y0), take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
A__SPLITAT(s(s(y0)), cons(y1, splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__SPLITAT(s(s(y0)), cons(y1, fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(s(y0), fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
MARK(natsFrom(X)) → MARK(X)
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(s(y0), afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
MARK(s(X)) → MARK(X)
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
MARK(splitAt(s(y0), head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
A__TAKE(N, XS) → MARK(N)
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__AFTERNTH(N, XS) → MARK(N)
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
MARK(tail(X)) → MARK(X)
MARK(head(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(y0), cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(afterNth(X1, X2)) → MARK(X2)
A__SPLITAT(s(s(y0)), cons(y1, 0)) → A__SPLITAT(s(mark(y0)), 0)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
MARK(pair(X1, X2)) → MARK(X1)
A__SPLITAT(s(s(y0)), cons(y1, afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__SPLITAT(s(s(y0)), cons(y1, natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__SPLITAT(s(s(y0)), cons(y1, tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(s(y0)), cons(y1, head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__SPLITAT(s(s(y0)), cons(y1, pair(x0, x1))) → A__SPLITAT(s(mark(y0)), pair(mark(x0), mark(x1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(splitAt(s(y0), natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(splitAt(s(y0), snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
MARK(splitAt(s(y0), tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ Narrowing

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ Narrowing

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ Narrowing

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ QDP

                              ↳ Narrowing

                                ↳ QDP

                                  ↳ DependencyGraphProof

                                    ↳ QDP

                                      ↳ Narrowing

                                        ↳ QDP

                                          ↳ DependencyGraphProof

                                            ↳ QDP

                                              ↳ Narrowing

                                                ↳ QDP

                                                  ↳ DependencyGraphProof

                                                    ↳ QDP

                                                      ↳ Narrowing

                                                        ↳ QDP

                                                          ↳ DependencyGraphProof

                                                            ↳ QDP

                                                              ↳ Narrowing

                                                                ↳ QDP

                                                                  ↳ DependencyGraphProof

                                                                    ↳ QDP

                                                                      ↳ Narrowing

                                                                        ↳ QDP

                                                                          ↳ DependencyGraphProof

                                                                            ↳ QDP

                                                                              ↳ Narrowing

                                                                                ↳ QDP

                                                                                  ↳ DependencyGraphProof

                                                                                    ↳ QDP

                                                                                      ↳ Narrowing

                                                                                        ↳ QDP

                                                                                          ↳ DependencyGraphProof

                                                                                            ↳ QDP

                                                                                              ↳ Narrowing

                                                                                                ↳ QDP

                                                                                                  ↳ DependencyGraphProof

                                                                                                    ↳ QDP

                                                                                                      ↳ QDPOrderProof

                                                                                                        ↳ QDP

                                                                                                          ↳ QDPOrderProof

                                                                                                            ↳ QDP

                                                                                                              ↳ QDPOrderProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QDPOrderProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ QDPOrderProof

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Narrowing

                                                                                                                            ↳ QDP

                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__AFTERNTH(head(x0), y1) → A__SND(a__splitAt(a__head(mark(x0)), mark(y1)))
A__TAKE(y0, sel(x0, x1)) → A__FST(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
A__AFTERNTH(afterNth(x0, x1), y1) → A__SND(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, sel(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__sel(mark(x0), mark(x1))))
A__SEL(splitAt(x0, x1), y1) → A__HEAD(a__afterNth(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__TAKE(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(head(x0), y1)) → A__SPLITAT(a__head(mark(x0)), mark(y1))
MARK(u(fst(x0), y1, y2, y3)) → A__U(a__fst(mark(x0)), y1, y2, y3)
A__TAKE(sel(x0, x1), y1) → A__FST(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SEL(cons(x0, x1), y1) → A__HEAD(a__afterNth(cons(mark(x0), x1), mark(y1)))
A__SPLITAT(s(0), cons(y1, y2)) → A__SPLITAT(0, mark(y2))
MARK(u(u(x0, x1, x2, x3), y1, y2, y3)) → A__U(a__u(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(u(afterNth(x0, x1), y1, y2, y3)) → A__U(a__afterNth(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(s(y0)), cons(y1, cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(head(fst(x0))) → A__HEAD(a__fst(mark(x0)))
A__AFTERNTH(y0, u(x0, x1, x2, x3)) → A__SND(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SPLITAT(s(s(y0)), cons(y1, u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
A__SEL(head(x0), y1) → A__HEAD(a__afterNth(a__head(mark(x0)), mark(y1)))
MARK(snd(u(x0, x1, x2, x3))) → A__SND(a__u(mark(x0), x1, x2, x3))
MARK(splitAt(s(y0), sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
A__TAKE(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(s(y0)), cons(y1, sel(x0, x1))) → A__SPLITAT(s(mark(y0)), a__sel(mark(x0), mark(x1)))
MARK(tail(take(x0, x1))) → A__TAIL(a__take(mark(x0), mark(x1)))
A__TAKE(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(take(X1, X2)) → MARK(X2)
A__AFTERNTH(pair(x0, x1), y1) → A__SND(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, splitAt(x0, x1)) → A__FST(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(head(natsFrom(x0))) → A__HEAD(a__natsFrom(mark(x0)))
A__AFTERNTH(0, y1) → A__SPLITAT(0, mark(y1))
MARK(splitAt(s(y0), u(x0, x1, x2, x3))) → A__SPLITAT(s(mark(y0)), a__u(mark(x0), x1, x2, x3))
A__SEL(snd(x0), y1) → A__HEAD(a__afterNth(a__snd(mark(x0)), mark(y1)))
A__TAKE(tail(x0), y1) → A__FST(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(splitAt(x0, x1), y1) → A__SND(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
MARK(fst(u(x0, x1, x2, x3))) → A__FST(a__u(mark(x0), x1, x2, x3))
A__SPLITAT(s(head(x0)), cons(y1, y2)) → A__SPLITAT(a__head(mark(x0)), mark(y2))
A__TAKE(y0, pair(x0, x1)) → A__FST(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__AFTERNTH(sel(x0, x1), y1) → A__SND(a__splitAt(a__sel(mark(x0), mark(x1)), mark(y1)))
A__TAKE(head(x0), y1) → A__FST(a__splitAt(a__head(mark(x0)), mark(y1)))
A__SPLITAT(s(s(y0)), cons(y1, take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
A__SEL(y0, s(x0)) → A__HEAD(a__afterNth(mark(y0), s(mark(x0))))
MARK(u(tail(x0), y1, y2, y3)) → A__U(a__tail(mark(x0)), y1, y2, y3)
MARK(u(X1, X2, X3, X4)) → MARK(X1)
A__TAKE(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__AFTERNTH(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__SPLITAT(s(take(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__SPLITAT(s(s(y0)), cons(y1, snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
MARK(snd(head(x0))) → A__SND(a__head(mark(x0)))
MARK(tail(tail(x0))) → A__TAIL(a__tail(mark(x0)))
A__SEL(take(x0, x1), y1) → A__HEAD(a__afterNth(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(tail(head(x0))) → A__TAIL(a__head(mark(x0)))
MARK(splitAt(tail(x0), y1)) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
MARK(fst(pair(x0, x1))) → A__FST(pair(mark(x0), mark(x1)))
A__AFTERNTH(s(x0), y1) → A__SND(a__splitAt(s(mark(x0)), mark(y1)))
A__AFTERNTH(fst(x0), y1) → A__SND(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__SEL(y0, afterNth(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, head(x0)) → A__HEAD(a__afterNth(mark(y0), a__head(mark(x0))))
MARK(snd(snd(x0))) → A__SND(a__snd(mark(x0)))
A__AFTERNTH(u(x0, x1, x2, x3), y1) → A__SND(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
MARK(splitAt(take(x0, x1), y1)) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
MARK(take(X1, X2)) → MARK(X1)
MARK(fst(sel(x0, x1))) → A__FST(a__sel(mark(x0), mark(x1)))
MARK(splitAt(afterNth(x0, x1), y1)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
MARK(snd(afterNth(x0, x1))) → A__SND(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(s(y0), splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(y0, snd(x0)) → A__SND(a__splitAt(mark(y0), a__snd(mark(x0))))
MARK(head(take(x0, x1))) → A__HEAD(a__take(mark(x0), mark(x1)))
MARK(sel(X1, X2)) → MARK(X1)
MARK(snd(take(x0, x1))) → A__SND(a__take(mark(x0), mark(x1)))
A__SEL(y0, take(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__take(mark(x0), mark(x1))))
A__AFTERNTH(N, XS) → MARK(XS)
MARK(splitAt(X1, X2)) → MARK(X2)
A__AFTERNTH(s(x0), y1) → A__SPLITAT(s(mark(x0)), mark(y1))
MARK(splitAt(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, nil) → A__SND(a__splitAt(mark(y0), nil))
MARK(afterNth(X1, X2)) → A__AFTERNTH(mark(X1), mark(X2))
A__SEL(afterNth(x0, x1), y1) → A__HEAD(a__afterNth(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(snd(tail(x0))) → A__SND(a__tail(mark(x0)))
A__SPLITAT(0, XS) → MARK(XS)
MARK(afterNth(X1, X2)) → MARK(X1)
MARK(head(afterNth(x0, x1))) → A__HEAD(a__afterNth(mark(x0), mark(x1)))
MARK(splitAt(s(y0), take(x0, x1))) → A__SPLITAT(s(mark(y0)), a__take(mark(x0), mark(x1)))
MARK(splitAt(0, y1)) → A__SPLITAT(0, mark(y1))
MARK(head(tail(x0))) → A__HEAD(a__tail(mark(x0)))
A__SPLITAT(s(s(y0)), cons(y1, splitAt(x0, x1))) → A__SPLITAT(s(mark(y0)), a__splitAt(mark(x0), mark(x1)))
A__TAKE(y0, cons(x0, x1)) → A__FST(a__splitAt(mark(y0), cons(mark(x0), x1)))
A__SPLITAT(s(s(y0)), cons(y1, fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
A__TAKE(N, XS) → MARK(XS)
A__SEL(y0, u(x0, x1, x2, x3)) → A__HEAD(a__afterNth(mark(y0), a__u(mark(x0), x1, x2, x3)))
MARK(natsFrom(X)) → MARK(X)
MARK(splitAt(s(y0), fst(x0))) → A__SPLITAT(s(mark(y0)), a__fst(mark(x0)))
A__TAKE(u(x0, x1, x2, x3), y1) → A__FST(a__splitAt(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__AFTERNTH(y0, fst(x0)) → A__SND(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SEL(N, XS) → A__AFTERNTH(mark(N), mark(XS))
A__SND(pair(XS, YS)) → MARK(YS)
A__SEL(nil, y1) → A__HEAD(a__afterNth(nil, mark(y1)))
A__SEL(y0, nil) → A__HEAD(a__afterNth(mark(y0), nil))
A__TAKE(y0, nil) → A__FST(a__splitAt(mark(y0), nil))
A__AFTERNTH(y0, cons(x0, x1)) → A__SND(a__splitAt(mark(y0), cons(mark(x0), x1)))
MARK(snd(sel(x0, x1))) → A__SND(a__sel(mark(x0), mark(x1)))
MARK(tail(afterNth(x0, x1))) → A__TAIL(a__afterNth(mark(x0), mark(x1)))
MARK(u(sel(x0, x1), y1, y2, y3)) → A__U(a__sel(mark(x0), mark(x1)), y1, y2, y3)
MARK(sel(X1, X2)) → A__SEL(mark(X1), mark(X2))
MARK(head(head(x0))) → A__HEAD(a__head(mark(x0)))
A__SPLITAT(s(snd(x0)), cons(y1, y2)) → A__SPLITAT(a__snd(mark(x0)), mark(y2))
MARK(fst(take(x0, x1))) → A__FST(a__take(mark(x0), mark(x1)))
A__SPLITAT(s(tail(x0)), cons(y1, y2)) → A__SPLITAT(a__tail(mark(x0)), mark(y2))
A__AFTERNTH(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
A__SPLITAT(s(sel(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y2))
A__AFTERNTH(tail(x0), y1) → A__SND(a__splitAt(a__tail(mark(x0)), mark(y1)))
A__TAKE(splitAt(x0, x1), y1) → A__FST(a__splitAt(a__splitAt(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, splitAt(x0, x1)) → A__HEAD(a__afterNth(mark(y0), a__splitAt(mark(x0), mark(x1))))
MARK(tail(cons(x0, x1))) → A__TAIL(cons(mark(x0), x1))
A__TAKE(y0, natsFrom(x0)) → A__FST(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__SEL(N, XS) → MARK(N)
A__TAKE(y0, afterNth(x0, x1)) → A__FST(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
MARK(splitAt(fst(x0), y1)) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
A__TAKE(sel(x0, x1), y1) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(tail(snd(x0))) → A__TAIL(a__snd(mark(x0)))
MARK(fst(fst(x0))) → A__FST(a__fst(mark(x0)))
A__SEL(y0, cons(x0, x1)) → A__HEAD(a__afterNth(mark(y0), cons(mark(x0), x1)))
MARK(fst(head(x0))) → A__FST(a__head(mark(x0)))
MARK(fst(tail(x0))) → A__FST(a__tail(mark(x0)))
MARK(fst(X)) → MARK(X)
A__SEL(y0, snd(x0)) → A__HEAD(a__afterNth(mark(y0), a__snd(mark(x0))))
A__SPLITAT(s(N), cons(X, XS)) → MARK(XS)
A__HEAD(cons(N, XS)) → MARK(N)
MARK(head(snd(x0))) → A__HEAD(a__snd(mark(x0)))
A__SEL(0, y1) → A__HEAD(a__afterNth(0, mark(y1)))
A__SEL(y0, 0) → A__HEAD(a__afterNth(mark(y0), 0))
MARK(splitAt(snd(x0), y1)) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
MARK(splitAt(s(y0), afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__AFTERNTH(y0, natsFrom(x0)) → A__SND(a__splitAt(mark(y0), a__natsFrom(mark(x0))))
A__U(pair(YS, ZS), N, X, XS) → MARK(ZS)
MARK(u(snd(x0), y1, y2, y3)) → A__U(a__snd(mark(x0)), y1, y2, y3)
A__SEL(sel(x0, x1), y1) → A__HEAD(a__afterNth(a__sel(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(afterNth(x0, x1)), cons(y1, y2)) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y2))
MARK(s(X)) → MARK(X)
A__SEL(N, XS) → MARK(XS)
A__TAKE(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(tail(fst(x0))) → A__TAIL(a__fst(mark(x0)))
A__AFTERNTH(y0, pair(x0, x1)) → A__SND(a__splitAt(mark(y0), pair(mark(x0), mark(x1))))
A__SEL(pair(x0, x1), y1) → A__HEAD(a__afterNth(pair(mark(x0), mark(x1)), mark(y1)))
A__SEL(y0, tail(x0)) → A__HEAD(a__afterNth(mark(y0), a__tail(mark(x0))))
A__FST(pair(XS, YS)) → MARK(XS)
A__AFTERNTH(fst(x0), y1) → A__SPLITAT(a__fst(mark(x0)), mark(y1))
MARK(snd(splitAt(x0, x1))) → A__SND(a__splitAt(mark(x0), mark(x1)))
A__AFTERNTH(snd(x0), y1) → A__SPLITAT(a__snd(mark(x0)), mark(y1))
A__TAKE(s(x0), y1) → A__FST(a__splitAt(s(mark(x0)), mark(y1)))
MARK(take(X1, X2)) → A__TAKE(mark(X1), mark(X2))
A__SEL(y0, natsFrom(x0)) → A__HEAD(a__afterNth(mark(y0), a__natsFrom(mark(x0))))
MARK(tail(sel(x0, x1))) → A__TAIL(a__sel(mark(x0), mark(x1)))
A__SEL(y0, fst(x0)) → A__HEAD(a__afterNth(mark(y0), a__fst(mark(x0))))
A__TAKE(y0, s(x0)) → A__FST(a__splitAt(mark(y0), s(mark(x0))))
A__AFTERNTH(y0, s(x0)) → A__SND(a__splitAt(mark(y0), s(mark(x0))))
MARK(natsFrom(X)) → A__NATSFROM(mark(X))
MARK(head(cons(x0, x1))) → A__HEAD(cons(mark(x0), x1))
MARK(tail(natsFrom(x0))) → A__TAIL(a__natsFrom(mark(x0)))
A__TAKE(y0, snd(x0)) → A__FST(a__splitAt(mark(y0), a__snd(mark(x0))))
A__TAKE(0, y1) → A__SPLITAT(0, mark(y1))
A__NATSFROM(N) → MARK(N)
MARK(fst(splitAt(x0, x1))) → A__FST(a__splitAt(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → A__SND(pair(mark(x0), mark(x1)))
A__TAKE(pair(x0, x1), y1) → A__FST(a__splitAt(pair(mark(x0), mark(x1)), mark(y1)))
A__TAKE(y0, u(x0, x1, x2, x3)) → A__FST(a__splitAt(mark(y0), a__u(mark(x0), x1, x2, x3)))
A__SEL(u(x0, x1, x2, x3), y1) → A__HEAD(a__afterNth(a__u(mark(x0), x1, x2, x3), mark(y1)))
A__TAKE(N, XS) → MARK(N)
MARK(snd(fst(x0))) → A__SND(a__fst(mark(x0)))
MARK(head(sel(x0, x1))) → A__HEAD(a__sel(mark(x0), mark(x1)))
MARK(splitAt(s(y0), head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
A__U(pair(YS, ZS), N, X, XS) → MARK(X)
A__TAKE(fst(x0), y1) → A__FST(a__splitAt(a__fst(mark(x0)), mark(y1)))
A__TAKE(snd(x0), y1) → A__FST(a__splitAt(a__snd(mark(x0)), mark(y1)))
MARK(sel(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SPLITAT(a__take(mark(x0), mark(x1)), mark(y1))
A__SEL(s(x0), y1) → A__HEAD(a__afterNth(s(mark(x0)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → MARK(N)
A__AFTERNTH(N, XS) → MARK(N)
MARK(head(X)) → MARK(X)
MARK(tail(X)) → MARK(X)
MARK(cons(X1, X2)) → MARK(X1)
A__AFTERNTH(y0, head(x0)) → A__SND(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(afterNth(x0, x1), y1) → A__FST(a__splitAt(a__afterNth(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(s(y0), cons(x0, x1))) → A__SPLITAT(s(mark(y0)), cons(mark(x0), x1))
MARK(afterNth(X1, X2)) → MARK(X2)
A__AFTERNTH(take(x0, x1), y1) → A__SND(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
MARK(u(pair(x0, x1), y1, y2, y3)) → A__U(pair(mark(x0), mark(x1)), y1, y2, y3)
A__SEL(fst(x0), y1) → A__HEAD(a__afterNth(a__fst(mark(x0)), mark(y1)))
MARK(u(take(x0, x1), y1, y2, y3)) → A__U(a__take(mark(x0), mark(x1)), y1, y2, y3)
MARK(pair(X1, X2)) → MARK(X1)
A__TAKE(y0, fst(x0)) → A__FST(a__splitAt(mark(y0), a__fst(mark(x0))))
A__SPLITAT(s(s(y0)), cons(y1, afterNth(x0, x1))) → A__SPLITAT(s(mark(y0)), a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, 0) → A__FST(a__splitAt(mark(y0), 0))
A__TAKE(0, y1) → A__FST(a__splitAt(0, mark(y1)))
A__SEL(y0, y1) → A__HEAD(a__snd(a__splitAt(mark(mark(y0)), mark(mark(y1)))))
A__SPLITAT(s(s(y0)), cons(y1, natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
A__AFTERNTH(snd(x0), y1) → A__SND(a__splitAt(a__snd(mark(x0)), mark(y1)))
A__SPLITAT(s(s(y0)), cons(y1, tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__TAIL(cons(N, XS)) → MARK(XS)
MARK(u(splitAt(x0, x1), y1, y2, y3)) → A__U(a__splitAt(mark(x0), mark(x1)), y1, y2, y3)
A__SPLITAT(s(s(y0)), cons(y1, head(x0))) → A__SPLITAT(s(mark(y0)), a__head(mark(x0)))
A__TAKE(take(x0, x1), y1) → A__FST(a__splitAt(a__take(mark(x0), mark(x1)), mark(y1)))
A__SPLITAT(s(N), cons(X, XS)) → A__U(a__splitAt(mark(N), mark(XS)), N, X, XS)
A__SEL(tail(x0), y1) → A__HEAD(a__afterNth(a__tail(mark(x0)), mark(y1)))
A__AFTERNTH(y0, sel(x0, x1)) → A__SND(a__splitAt(mark(y0), a__sel(mark(x0), mark(x1))))
MARK(u(head(x0), y1, y2, y3)) → A__U(a__head(mark(x0)), y1, y2, y3)
MARK(splitAt(s(y0), natsFrom(x0))) → A__SPLITAT(s(mark(y0)), a__natsFrom(mark(x0)))
A__SPLITAT(s(fst(x0)), cons(y1, y2)) → A__SPLITAT(a__fst(mark(x0)), mark(y2))
MARK(splitAt(s(y0), snd(x0))) → A__SPLITAT(s(mark(y0)), a__snd(mark(x0)))
MARK(fst(snd(x0))) → A__FST(a__snd(mark(x0)))
MARK(splitAt(sel(x0, x1), y1)) → A__SPLITAT(a__sel(mark(x0), mark(x1)), mark(y1))
MARK(fst(afterNth(x0, x1))) → A__FST(a__afterNth(mark(x0), mark(x1)))
A__TAKE(y0, take(x0, x1)) → A__FST(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))
MARK(pair(X1, X2)) → MARK(X2)
A__AFTERNTH(y0, splitAt(x0, x1)) → A__SND(a__splitAt(mark(y0), a__splitAt(mark(x0), mark(x1))))
A__AFTERNTH(y0, tail(x0)) → A__SND(a__splitAt(mark(y0), a__tail(mark(x0))))
A__SEL(natsFrom(x0), y1) → A__HEAD(a__afterNth(a__natsFrom(mark(x0)), mark(y1)))
MARK(snd(X)) → MARK(X)
A__AFTERNTH(afterNth(x0, x1), y1) → A__SPLITAT(a__afterNth(mark(x0), mark(x1)), mark(y1))
A__TAKE(y0, head(x0)) → A__FST(a__splitAt(mark(y0), a__head(mark(x0))))
A__TAKE(head(x0), y1) → A__SPLITAT(a__head(mark(x0)), mark(y1))
A__TAKE(tail(x0), y1) → A__SPLITAT(a__tail(mark(x0)), mark(y1))
A__TAKE(y0, tail(x0)) → A__FST(a__splitAt(mark(y0), a__tail(mark(x0))))
A__AFTERNTH(y0, 0) → A__SND(a__splitAt(mark(y0), 0))
A__AFTERNTH(0, y1) → A__SND(a__splitAt(0, mark(y1)))
A__AFTERNTH(y0, afterNth(x0, x1)) → A__SND(a__splitAt(mark(y0), a__afterNth(mark(x0), mark(x1))))
A__SEL(y0, pair(x0, x1)) → A__HEAD(a__afterNth(mark(y0), pair(mark(x0), mark(x1))))
MARK(splitAt(s(y0), tail(x0))) → A__SPLITAT(s(mark(y0)), a__tail(mark(x0)))
A__AFTERNTH(y0, take(x0, x1)) → A__SND(a__splitAt(mark(y0), a__take(mark(x0), mark(x1))))

The TRS R consists of the following rules:

a__natsFrom(N) → cons(mark(N), natsFrom(s(N)))
a__fst(pair(XS, YS)) → mark(XS)
a__snd(pair(XS, YS)) → mark(YS)
a__splitAt(0, XS) → pair(nil, mark(XS))
a__splitAt(s(N), cons(X, XS)) → a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
a__u(pair(YS, ZS), N, X, XS) → pair(cons(mark(X), YS), mark(ZS))
a__head(cons(N, XS)) → mark(N)
a__tail(cons(N, XS)) → mark(XS)
a__sel(N, XS) → a__head(a__afterNth(mark(N), mark(XS)))
a__take(N, XS) → a__fst(a__splitAt(mark(N), mark(XS)))
a__afterNth(N, XS) → a__snd(a__splitAt(mark(N), mark(XS)))
mark(natsFrom(X)) → a__natsFrom(mark(X))
mark(fst(X)) → a__fst(mark(X))
mark(snd(X)) → a__snd(mark(X))
mark(splitAt(X1, X2)) → a__splitAt(mark(X1), mark(X2))
mark(u(X1, X2, X3, X4)) → a__u(mark(X1), X2, X3, X4)
mark(head(X)) → a__head(mark(X))
mark(tail(X)) → a__tail(mark(X))
mark(sel(X1, X2)) → a__sel(mark(X1), mark(X2))
mark(afterNth(X1, X2)) → a__afterNth(mark(X1), mark(X2))
mark(take(X1, X2)) → a__take(mark(X1), mark(X2))
mark(cons(X1, X2)) → cons(mark(X1), X2)
mark(s(X)) → s(mark(X))
mark(pair(X1, X2)) → pair(mark(X1), mark(X2))
mark(0) → 0
mark(nil) → nil
a__natsFrom(X) → natsFrom(X)
a__fst(X) → fst(X)
a__snd(X) → snd(X)
a__splitAt(X1, X2) → splitAt(X1, X2)
a__u(X1, X2, X3, X4) → u(X1, X2, X3, X4)
a__head(X) → head(X)
a__tail(X) → tail(X)
a__sel(X1, X2) → sel(X1, X2)
a__afterNth(X1, X2) → afterNth(X1, X2)
a__take(X1, X2) → take(X1, X2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.